package o;

import com.huawei.appgallery.festivalanimation.particle.modifiers.SizeModifier;
import java.lang.reflect.Array;
import o.fyq.a;
import o.fyq.b;
import o.fyq.d;

public class gac {
    static final /* synthetic */ boolean ˎ;
    private static Integer ـ = new Integer(1234598372);
    private int ʻ;
    private gae ʻॱ;
    private fzt ʼ;
    private gap[][] ʼॱ;
    private final fzp ʽ;
    private final fzq ʽॱ;
    private final fzq ʾ;
    private final fzd ʿ;
    private final gag ˈ;
    private final fzn ˉ;
    protected int ˊ;
    private final gbd ˊˊ;
    private final gaf ˊˋ;
    private fyb ˊॱ;
    private final fzp ˊᐝ;
    protected fzu ˋ;
    private final fzp ˋˊ;
    private final fzq ˋˋ;
    private float ˋॱ;
    private final fzx ˋᐝ;
    private fzt[] ˌ;
    private final b ˍ;
    private final fzx ˎˎ;
    private final gag ˎˏ;
    public int ˏ;
    private final fzr ˏˎ;
    private final fzt[] ˏˏ;
    private final gaz ˏॱ;
    private final fzr ˑ;
    private fyc ͺ;
    private final a ͺॱ;
    public int ॱ;
    private float ॱʻ;
    private final fzp ॱʼ;
    private float ॱʽ;
    private boolean ॱˊ;
    private boolean ॱˋ;
    private boolean ॱˎ;
    private final fzp ॱͺ;
    private int ॱॱ;
    private boolean ॱᐝ;
    private gaw ᐝ;
    private final fzp ᐝˊ;
    private final fzp ᐝˋ;
    private boolean ᐝॱ;
    private final fzd ᐝᐝ;
    private final fzp ᐧ;
    private final fzp ᐨ;
    private final gbd ꜟ;

    static {
        boolean z;
        if (gac.class.desiredAssertionStatus()) {
            z = false;
        } else {
            z = true;
        }
        ˎ = z;
    }

    public gac(fzp o_fzp) {
        this(o_fzp, new gbf(100, 10));
    }

    public gac(fzp o_fzp, gaz o_gaz) {
        this(o_fzp, o_gaz, new fyv());
    }

    public gac(fzp o_fzp, gaz o_gaz, fyt o_fyt) {
        this(o_fzp, o_gaz, new fyu(o_fyt));
    }

    public gac(fzp o_fzp, gaz o_gaz, fyw o_fyw) {
        this.ॱ = 0;
        this.ˏ = 0;
        this.ʽ = new fzp();
        this.ʼॱ = (gap[][]) Array.newInstance(gap.class, new int[]{fze.values().length, fze.values().length});
        this.ˈ = new gag();
        this.ʽॱ = new fzq();
        this.ʾ = new fzq();
        this.ʿ = new fzd();
        this.ˉ = new fzn();
        this.ˋˊ = new fzp();
        this.ˊᐝ = new fzp();
        this.ˊˊ = new gbd();
        this.ˊˋ = new gaf();
        this.ˋᐝ = new fzx();
        this.ˌ = new fzt[10];
        this.ˋˋ = new fzq();
        this.ˎˎ = new fzx();
        this.ˍ = new b();
        this.ͺॱ = new a();
        this.ˎˏ = new gag();
        this.ˏˏ = new fzt[2];
        this.ˏˎ = new fzr();
        this.ˑ = new fzr();
        this.ॱʻ = 0.12f;
        this.ॱʽ = SizeModifier.STABLE_STATE_SCALE;
        this.ॱͺ = new fzp();
        this.ॱʼ = new fzp();
        this.ᐝᐝ = new fzd(0.4f, 0.4f, 1.0f);
        this.ᐝˋ = new fzp();
        this.ᐧ = new fzp();
        this.ᐝˊ = new fzp();
        this.ᐨ = new fzp();
        this.ꜟ = new gbd();
        this.ˏॱ = o_gaz;
        this.ˊॱ = null;
        this.ͺ = null;
        this.ʼ = null;
        this.ᐝ = null;
        this.ॱॱ = 0;
        this.ʻ = 0;
        this.ॱˋ = true;
        this.ᐝॱ = true;
        this.ॱᐝ = false;
        this.ॱˎ = true;
        this.ॱˊ = true;
        this.ʽ.ॱ(o_fzp);
        this.ˊ = 4;
        this.ˋॱ = 0.0f;
        this.ˋ = new fzu(this, o_fyw);
        this.ʻॱ = new gae();
        ʼ();
    }

    private void ˋ(gay<gal> o_gay_o_gal, fze o_fze, fze o_fze2) {
        gap o_gap = new gap();
        o_gap.ॱ = o_gay_o_gal;
        o_gap.ˋ = true;
        this.ʼॱ[o_fze.ordinal()][o_fze2.ordinal()] = o_gap;
        if (o_fze != o_fze2) {
            o_gap = new gap();
            o_gap.ॱ = o_gay_o_gal;
            o_gap.ˋ = false;
            this.ʼॱ[o_fze2.ordinal()][o_fze.ordinal()] = o_gap;
        }
    }

    private void ʼ() {
        ˋ(this.ˏॱ.ˋ(), fze.CIRCLE, fze.CIRCLE);
        ˋ(this.ˏॱ.ˎ(), fze.POLYGON, fze.CIRCLE);
        ˋ(this.ˏॱ.ˏ(), fze.POLYGON, fze.POLYGON);
        ˋ(this.ˏॱ.ॱ(), fze.EDGE, fze.CIRCLE);
        ˋ(this.ˏॱ.ˊ(), fze.EDGE, fze.POLYGON);
        ˋ(this.ˏॱ.ॱॱ(), fze.CHAIN, fze.CIRCLE);
        ˋ(this.ˏॱ.ᐝ(), fze.CHAIN, fze.POLYGON);
    }

    public gal ˊ(gab o_gab, int i, gab o_gab2, int i2) {
        gap o_gap = this.ʼॱ[o_gab.ˎ().ordinal()][o_gab2.ˎ().ordinal()];
        if (o_gap == null) {
            return null;
        }
        if (o_gap.ˋ) {
            gal o_gal = (gal) o_gap.ॱ.ˊ();
            o_gal.ˎ(o_gab, i, o_gab2, i2);
            return o_gal;
        }
        o_gal = (gal) o_gap.ॱ.ˊ();
        o_gal.ˎ(o_gab2, i2, o_gab, i);
        return o_gal;
    }

    public void ॱ(gal o_gal) {
        gab ˊ = o_gal.ˊ();
        gab ʽ = o_gal.ʽ();
        if (!(o_gal.ˏॱ.ˏ <= 0 || ˊ.ˋ() || ʽ.ˋ())) {
            ˊ.ॱ().ˏ(true);
            ʽ.ॱ().ˏ(true);
        }
        this.ʼॱ[ˊ.ˎ().ordinal()][ʽ.ˎ().ordinal()].ॱ.ˋ(o_gal);
    }

    public gaz ॱ() {
        return this.ˏॱ;
    }

    public fzt ˊ(fzw o_fzw) {
        if (!ˎ && ˊ()) {
            throw new AssertionError();
        } else if (ˊ()) {
            return null;
        } else {
            fzt o_fzt = new fzt(o_fzw, this);
            o_fzt.ͺ = null;
            o_fzt.ॱˊ = this.ʼ;
            if (this.ʼ != null) {
                this.ʼ.ͺ = o_fzt;
            }
            this.ʼ = o_fzt;
            this.ॱॱ++;
            return o_fzt;
        }
    }

    public void ॱ(fzt o_fzt) {
        if (!ˎ && this.ॱॱ <= 0) {
            throw new AssertionError();
        } else if (!ˎ && ˊ()) {
            throw new AssertionError();
        } else if (!ˊ()) {
            gaj o_gaj = o_fzt.ॱˋ;
            while (o_gaj != null) {
                gaj o_gaj2 = o_gaj.ˊ;
                this.ˋ.ˎ(o_gaj.ॱ);
                o_gaj = o_gaj2;
            }
            o_fzt.ॱˋ = null;
            gab o_gab = o_fzt.ˋॱ;
            while (o_gab != null) {
                gab o_gab2 = o_gab.ˋ;
                if (this.ˊॱ != null) {
                    this.ˊॱ.ˋ(o_gab);
                }
                o_gab.ˎ(this.ˋ.ˊ);
                o_gab.ʼ();
                o_fzt.ˋॱ = o_gab2;
                o_fzt.ˏॱ--;
                o_gab = o_gab2;
            }
            o_fzt.ˋॱ = null;
            o_fzt.ˏॱ = 0;
            if (o_fzt.ͺ != null) {
                o_fzt.ͺ.ॱˊ = o_fzt.ॱˊ;
            }
            if (o_fzt.ॱˊ != null) {
                o_fzt.ॱˊ.ͺ = o_fzt.ͺ;
            }
            if (o_fzt == this.ʼ) {
                this.ʼ = o_fzt.ॱˊ;
            }
            this.ॱॱ--;
        }
    }

    public void ˋ(float f, int i, int i2) {
        this.ʽॱ.ॱ();
        this.ʾ.ॱ();
        if ((this.ˊ & 1) == 1) {
            this.ˋ.ˊ();
            this.ˊ &= -2;
        }
        this.ˊ |= 2;
        this.ˈ.ˎ = f;
        this.ˈ.ˏ = i;
        this.ˈ.ॱ = i2;
        if (f > 0.0f) {
            this.ˈ.ˋ = 1.0f / f;
        } else {
            this.ˈ.ˋ = 0.0f;
        }
        this.ˈ.ˊ = this.ˋॱ * f;
        this.ˈ.ॱॱ = this.ॱˋ;
        this.ʻॱ.ˎ.ˋ(this.ʾ.ˎ());
        this.ʾ.ॱ();
        this.ˋ.ˏ();
        this.ʻॱ.ˋ.ˋ(this.ʾ.ˎ());
        if (this.ॱˎ && this.ˈ.ˎ > 0.0f) {
            this.ʾ.ॱ();
            this.ʾ.ॱ();
            ˋ(this.ˈ);
            this.ʻॱ.ˊ.ˋ(this.ʾ.ˎ());
        }
        if (this.ᐝॱ && this.ˈ.ˎ > 0.0f) {
            this.ʾ.ॱ();
            ˏ(this.ˈ);
            this.ʻॱ.ᐝ.ˋ(this.ʾ.ˎ());
        }
        if (this.ˈ.ˎ > 0.0f) {
            this.ˋॱ = this.ˈ.ˋ;
        }
        if ((this.ˊ & 4) == 4) {
            ˎ();
        }
        this.ˊ &= -3;
        this.ʻॱ.ॱ.ˋ(this.ʽॱ.ˎ());
    }

    public void ˎ() {
        for (fzt o_fzt = this.ʼ; o_fzt != null; o_fzt = o_fzt.ˏॱ()) {
            o_fzt.ʼ.ˊ();
            o_fzt.ᐝ = 0.0f;
        }
    }

    public fzt ˋ() {
        return this.ʼ;
    }

    public void ˎ(fzp o_fzp) {
        this.ʽ.ॱ(o_fzp);
    }

    public fzp ˏ() {
        return this.ʽ;
    }

    public boolean ˊ() {
        return (this.ˊ & 2) == 2;
    }

    private void ˋ(gag o_gag) {
        fzt o_fzt;
        this.ʻॱ.ʼ.ˏ();
        this.ʻॱ.ʻ.ˏ();
        this.ʻॱ.ॱॱ.ˏ();
        for (o_fzt = this.ʼ; o_fzt != null; o_fzt = o_fzt.ॱˊ) {
            o_fzt.ॱ.ˊ(o_fzt.ˋ);
        }
        this.ˋᐝ.ˎ(this.ॱॱ, this.ˋ.ˏ, this.ʻ, this.ˋ.ॱ);
        o_fzt = this.ʼ;
        while (o_fzt != null) {
            o_fzt.ˏ &= -2;
            o_fzt = o_fzt.ॱˊ;
        }
        gal o_gal = this.ˋ.ˋ;
        while (o_gal != null) {
            o_gal.ॱ &= -2;
            o_gal = o_gal.ॱॱ;
        }
        for (gaw o_gaw = this.ᐝ; o_gaw != null; o_gaw = o_gaw.ˎ) {
            o_gaw.ॱ = false;
        }
        int i = this.ॱॱ;
        if (this.ˌ.length < i) {
            this.ˌ = new fzt[i];
        }
        fzt o_fzt2 = this.ʼ;
        while (o_fzt2 != null) {
            if ((o_fzt2.ˏ & 1) != 1 && o_fzt2.ʼ() && o_fzt2.ˊॱ() && o_fzt2.ʽ() != fzs.STATIC) {
                int i2;
                this.ˋᐝ.ˋ();
                this.ˌ[0] = o_fzt2;
                o_fzt2.ˏ |= 1;
                int i3 = 1;
                while (i3 > 0) {
                    i3--;
                    fzt o_fzt3 = this.ˌ[i3];
                    if (ˎ || o_fzt3.ˊॱ()) {
                        this.ˋᐝ.ˊ(o_fzt3);
                        o_fzt3.ˏ(true);
                        if (o_fzt3.ʽ() != fzs.STATIC) {
                            i2 = i3;
                            for (gaj o_gaj = o_fzt3.ॱˋ; o_gaj != null; o_gaj = o_gaj.ˊ) {
                                gal o_gal2 = o_gaj.ॱ;
                                if ((o_gal2.ॱ & 1) != 1 && o_gal2.ˋ() && o_gal2.ˎ()) {
                                    boolean z = o_gal2.ʻ.ʻ;
                                    boolean z2 = o_gal2.ʼ.ʻ;
                                    if (!(z || z2)) {
                                        this.ˋᐝ.ˎ(o_gal2);
                                        o_gal2.ॱ |= 1;
                                        fzt o_fzt4 = o_gaj.ˎ;
                                        if ((o_fzt4.ˏ & 1) == 1) {
                                            continue;
                                        } else if (ˎ || i2 < i) {
                                            i3 = i2 + 1;
                                            this.ˌ[i2] = o_fzt4;
                                            o_fzt4.ˏ |= 1;
                                            i2 = i3;
                                        } else {
                                            throw new AssertionError();
                                        }
                                    }
                                }
                            }
                            for (gax o_gax = o_fzt3.ᐝॱ; o_gax != null; o_gax = o_gax.ˊ) {
                                if (!o_gax.ॱ.ॱ) {
                                    o_fzt3 = o_gax.ˎ;
                                    if (o_fzt3.ˊॱ()) {
                                        this.ˋᐝ.ˋ(o_gax.ॱ);
                                        o_gax.ॱ.ॱ = true;
                                        if ((o_fzt3.ˏ & 1) == 1) {
                                            continue;
                                        } else if (ˎ || i2 < i) {
                                            i3 = i2 + 1;
                                            this.ˌ[i2] = o_fzt3;
                                            o_fzt3.ˏ |= 1;
                                            i2 = i3;
                                        } else {
                                            throw new AssertionError();
                                        }
                                    }
                                    continue;
                                }
                            }
                            i3 = i2;
                        }
                    } else {
                        throw new AssertionError();
                    }
                }
                this.ˋᐝ.ˋ(this.ʻॱ, o_gag, this.ʽ, this.ॱˊ);
                for (i2 = 0; i2 < this.ˋᐝ.ʽ; i2++) {
                    fzt o_fzt5 = this.ˋᐝ.ˎ[i2];
                    if (o_fzt5.ʽ() == fzs.STATIC) {
                        o_fzt5.ˏ &= -2;
                    }
                }
            }
            o_fzt2 = o_fzt2.ॱˊ;
        }
        this.ʻॱ.ʼ.ˋ();
        this.ʻॱ.ʻ.ˋ();
        this.ʻॱ.ॱॱ.ˋ();
        this.ˋˋ.ॱ();
        o_fzt = this.ʼ;
        while (o_fzt != null) {
            if (!((o_fzt.ˏ & 1) == 0 || o_fzt.ʽ() == fzs.STATIC)) {
                o_fzt.ॱˊ();
            }
            o_fzt = o_fzt.ˏॱ();
        }
        this.ˋ.ˊ();
        this.ʻॱ.ʽ.ˋ(this.ˋˋ.ˎ());
    }

    private void ˏ(gag o_gag) {
        fzx o_fzx = this.ˎˎ;
        o_fzx.ˎ(fzo.ॱˎ * 2, fzo.ॱˎ, 0, this.ˋ.ॱ);
        if (this.ॱˎ) {
            fzt o_fzt = this.ʼ;
            while (o_fzt != null) {
                o_fzt.ˏ &= -2;
                o_fzt.ʻ.ॱॱ = 0.0f;
                o_fzt = o_fzt.ॱˊ;
            }
            gal o_gal = this.ˋ.ˋ;
            while (o_gal != null) {
                o_gal.ॱ &= -34;
                o_gal.ͺ = 0.0f;
                o_gal.ॱˊ = 1.0f;
                o_gal = o_gal.ॱॱ;
            }
        }
        while (true) {
            gal o_gal2 = null;
            float f = 1.0f;
            gal o_gal3 = this.ˋ.ˋ;
            while (o_gal3 != null) {
                gal o_gal4;
                fzt ॱ;
                if (!o_gal3.ˋ()) {
                    o_gal4 = o_gal2;
                } else if (o_gal3.ͺ > ((float) fzo.ॱᐝ)) {
                    o_gal4 = o_gal2;
                } else {
                    float f2;
                    if ((o_gal3.ॱ & 32) != 0) {
                        f2 = o_gal3.ॱˊ;
                    } else {
                        gab ˊ = o_gal3.ˊ();
                        gab ʽ = o_gal3.ʽ();
                        if (!ˊ.ˋ()) {
                            if (ʽ.ˋ()) {
                                o_gal4 = o_gal2;
                            } else {
                                ॱ = ˊ.ॱ();
                                fzt ॱ2 = ʽ.ॱ();
                                fzs o_fzs = ॱ.ˊ;
                                fzs o_fzs2 = ॱ2.ˊ;
                                if (ˎ || o_fzs == fzs.DYNAMIC || o_fzs2 == fzs.DYNAMIC) {
                                    Object obj = (!ॱ.ʼ() || o_fzs == fzs.STATIC) ? null : 1;
                                    Object obj2 = (!ॱ2.ʼ() || o_fzs2 == fzs.STATIC) ? null : 1;
                                    if (obj == null && obj2 == null) {
                                        o_gal4 = o_gal2;
                                    } else {
                                        obj = (ॱ.ᐝ() || o_fzs != fzs.DYNAMIC) ? 1 : null;
                                        obj2 = (ॱ2.ᐝ() || o_fzs2 != fzs.DYNAMIC) ? 1 : null;
                                        if (obj == null && obj2 == null) {
                                            o_gal4 = o_gal2;
                                        } else {
                                            f2 = ॱ.ʻ.ॱॱ;
                                            if (ॱ.ʻ.ॱॱ < ॱ2.ʻ.ॱॱ) {
                                                f2 = ॱ2.ʻ.ॱॱ;
                                                ॱ.ʻ.ˋ(f2);
                                            } else if (ॱ2.ʻ.ॱॱ < ॱ.ʻ.ॱॱ) {
                                                f2 = ॱ.ʻ.ॱॱ;
                                                ॱ2.ʻ.ˋ(f2);
                                            }
                                            if (ˎ || f2 < 1.0f) {
                                                int ᐝ = o_gal3.ᐝ();
                                                int ʻ = o_gal3.ʻ();
                                                b bVar = this.ˍ;
                                                bVar.ˊ.ˊ(ˊ.ˏ(), ᐝ);
                                                bVar.ˋ.ˊ(ʽ.ˏ(), ʻ);
                                                bVar.ˏ.ˊ(ॱ.ʻ);
                                                bVar.ˎ.ˊ(ॱ2.ʻ);
                                                bVar.ॱ = 1.0f;
                                                this.ˏॱ.ʼ().ˎ(this.ͺॱ, bVar);
                                                float f3 = this.ͺॱ.ॱ;
                                                if (this.ͺॱ.ˋ == d.TOUCHING) {
                                                    f2 = fzm.ॱ(f2 + (f3 * (1.0f - f2)), 1.0f);
                                                } else {
                                                    f2 = 1.0f;
                                                }
                                                o_gal3.ॱˊ = f2;
                                                o_gal3.ॱ |= 32;
                                            } else {
                                                throw new AssertionError();
                                            }
                                        }
                                    }
                                }
                                throw new AssertionError();
                            }
                        }
                        o_gal4 = o_gal2;
                    }
                    if (f2 < f) {
                        f = f2;
                        o_gal4 = o_gal3;
                    }
                    o_gal4 = o_gal2;
                }
                o_gal3 = o_gal3.ॱॱ;
                o_gal2 = o_gal4;
            }
            if (o_gal2 == null || 0.9999988f < f) {
                this.ॱˎ = true;
            } else {
                gab ˊ2 = o_gal2.ˊ();
                gab ʽ2 = o_gal2.ʽ();
                fzt ॱ3 = ˊ2.ॱ();
                fzt ॱ4 = ʽ2.ॱ();
                this.ˏˎ.ˊ(ॱ3.ʻ);
                this.ˑ.ˊ(ॱ4.ʻ);
                ॱ3.ˋ(f);
                ॱ4.ˋ(f);
                o_gal2.ˋ(this.ˋ.ॱ);
                o_gal2.ॱ &= -33;
                o_gal2.ͺ += 1.0f;
                if (o_gal2.ˋ() && o_gal2.ˎ()) {
                    gaj o_gaj;
                    ॱ3.ˏ(true);
                    ॱ4.ˏ(true);
                    o_fzx.ˋ();
                    o_fzx.ˊ(ॱ3);
                    o_fzx.ˊ(ॱ4);
                    o_fzx.ˎ(o_gal2);
                    ॱ3.ˏ |= 1;
                    ॱ4.ˏ |= 1;
                    o_gal2.ॱ |= 1;
                    this.ˏˏ[0] = ॱ3;
                    this.ˏˏ[1] = ॱ4;
                    for (int i = 0; i < 2; i++) {
                        fzt o_fzt2 = this.ˏˏ[i];
                        if (o_fzt2.ˊ == fzs.DYNAMIC) {
                            for (o_gaj = o_fzt2.ॱˋ; o_gaj != null && o_fzx.ʽ != o_fzx.ᐝ && o_fzx.ʻ != o_fzx.ͺ; o_gaj = o_gaj.ˊ) {
                                gal o_gal5 = o_gaj.ॱ;
                                if ((o_gal5.ॱ & 1) == 0) {
                                    ॱ = o_gaj.ˎ;
                                    if (ॱ.ˊ != fzs.DYNAMIC || o_fzt2.ᐝ() || ॱ.ᐝ()) {
                                        boolean z = o_gal5.ʻ.ʻ;
                                        boolean z2 = o_gal5.ʼ.ʻ;
                                        if (!(z || z2)) {
                                            this.ˏˎ.ˊ(ॱ.ʻ);
                                            if ((ॱ.ˏ & 1) == 0) {
                                                ॱ.ˋ(f);
                                            }
                                            o_gal5.ˋ(this.ˋ.ॱ);
                                            if (!o_gal5.ˋ()) {
                                                ॱ.ʻ.ˊ(this.ˏˎ);
                                                ॱ.ˋॱ();
                                            } else if (o_gal5.ˎ()) {
                                                o_gal5.ॱ |= 1;
                                                o_fzx.ˎ(o_gal5);
                                                if ((ॱ.ˏ & 1) == 0) {
                                                    ॱ.ˏ |= 1;
                                                    if (ॱ.ˊ != fzs.STATIC) {
                                                        ॱ.ˏ(true);
                                                    }
                                                    o_fzx.ˊ(ॱ);
                                                }
                                            } else {
                                                ॱ.ʻ.ˊ(this.ˏˎ);
                                                ॱ.ˋॱ();
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    this.ˎˏ.ˎ = (1.0f - f) * o_gag.ˎ;
                    this.ˎˏ.ˋ = 1.0f / this.ˎˏ.ˎ;
                    this.ˎˏ.ˊ = 1.0f;
                    this.ˎˏ.ॱ = 20;
                    this.ˎˏ.ˏ = o_gag.ˏ;
                    this.ˎˏ.ॱॱ = false;
                    o_fzx.ˎ(this.ˎˏ, ॱ3.ˎ, ॱ4.ˎ);
                    for (int i2 = 0; i2 < o_fzx.ʽ; i2++) {
                        fzt o_fzt3 = o_fzx.ˎ[i2];
                        o_fzt3.ˏ &= -2;
                        if (o_fzt3.ˊ == fzs.DYNAMIC) {
                            o_fzt3.ॱˊ();
                            for (o_gaj = o_fzt3.ॱˋ; o_gaj != null; o_gaj = o_gaj.ˊ) {
                                o_gal2 = o_gaj.ॱ;
                                o_gal2.ॱ &= -34;
                            }
                        }
                    }
                    this.ˋ.ˊ();
                    if (this.ॱᐝ) {
                        this.ॱˎ = false;
                        return;
                    }
                } else {
                    o_gal2.ˎ(false);
                    ॱ3.ʻ.ˊ(this.ˏˎ);
                    ॱ4.ʻ.ˊ(this.ˑ);
                    ॱ3.ˋॱ();
                    ॱ4.ˋॱ();
                }
            }
        }
        this.ॱˎ = true;
    }
}
